package com.ruifu.doc.service.impl;

import com.fhzncloud.cloud.admin.api.feign.RemoteDeptService;
import com.fhzncloud.cloud.common.security.service.CloudUser;
import com.github.pagehelper.Page;
import com.github.pagehelper.PageHelper;
import com.ruifu.common.config.ActConstants;
import com.ruifu.common.eneity.ConversionTaskQueue;
import com.ruifu.common.feign.RemoteActService;
import com.ruifu.common.po.*;
import com.ruifu.common.utils.AscllCodeUtils;
import com.ruifu.common.utils.BeanConverter;
import com.ruifu.common.utils.FileUtils;
import com.ruifu.common.utils.FindPermissionCommon;
import com.ruifu.common.vo.PageResultVO;
import com.ruifu.common.vo.actanddoc.ProccessTaskVO;
import com.ruifu.doc.conf.DirectConfig;
import com.ruifu.doc.conf.DocFinal;
import com.ruifu.doc.conf.FileConfig;
import com.ruifu.doc.dto.docmaster.DmDocMasterInsertDTO;
import com.ruifu.doc.dto.docver.DmDocVerInsertDTO;
import com.ruifu.doc.dto.docver.DmDocVerPLInsertDTO;
import com.ruifu.doc.dto.docver.DmDocVerQueryDTO;
import com.ruifu.doc.dto.docver.DmDocVerUpdateDTO;
import com.ruifu.doc.mapper.*;
import com.ruifu.doc.permissionsObject.DocPermissionObject;
import com.ruifu.doc.service.DmDocVerService;
import com.ruifu.doc.service.DmFileService;
import com.ruifu.doc.utils.FastDFSClient;
import com.ruifu.doc.utils.GetPreviewFileTypeUtils;
import com.ruifu.doc.vo.docver.DmDocVerVO;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.io.FilenameUtils;
import org.apache.commons.io.IOUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.mock.web.MockMultipartFile;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.multipart.MultipartFile;

import java.io.File;
import java.io.FileInputStream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * @author nyr
 * @create 2019/9/18
 */
@Service
@Transactional(rollbackFor = Exception.class)
@Slf4j
public class DmDocVerServiceImpl implements DmDocVerService {
    @Autowired(required = false)
    private DmDocVerMapper dmDocVerMapper;

    @Autowired(required = false)
    private DmDocMasterMapper dmDocMasterMapper;

    @Autowired
    private DmFileService dmFileService;

    @Autowired(required = false)
    private DmDoccMapper dmDoccMapper;

    @Autowired(required = false)
    private DmFileMapper dmFileMapper;

    @Autowired
    private FastDFSClient fastDFSClient;

    @Autowired
    GetPreviewFileTypeUtils getPreviewFileTypeUtils;

    @Autowired
    private RemoteActService remoteActService;
    /**
     * 文件操作配置类
     */
    @Autowired
    private FileConfig fileConfig;

    /**
     * rabbitMq操作类
     */
    @Autowired
    private AmqpTemplate rabbitTemplate;


    @Autowired(required = false)
    private ObjectPermissionsAuthorizationMapper objectPermissionsAuthorizationMapper;

    @Autowired
    RemoteDeptService remoteDeptService;

    /**
     * 联合查询
     *
     * @param pageNum
     * @param pageSize
     * @param dmDocVerQueryDTO
     * @param cloudUser
     * @return
     */
    @Override
    public PageResultVO findByQuery(int pageNum, int pageSize, DmDocVerQueryDTO dmDocVerQueryDTO, CloudUser cloudUser) {
        //开启分页
        PageHelper.startPage(pageNum, pageSize);
        Page<DmDocVer> page = (Page<DmDocVer>) dmDocVerMapper.findByQuery(dmDocVerQueryDTO, cloudUser);
        List<DmDocVerVO> dmDocVerVOS = BeanConverter.copyList(page.getResult(), DmDocVerVO.class);
        for (DmDocVerVO dmDocVerVO : dmDocVerVOS) {
            dmDocVerVO.setPermissionByUserIdAndPtId(this.findPermissionByUserIdAndPtId(cloudUser, dmDocVerVO.getDvDvId()));
        }
        return new PageResultVO(page.getTotal(),dmDocVerVOS);
    }

    /**
     * 联合查询不分页
     *
     * @param dmDocVerQueryDTO
     * @param cloudUser
     * @return
     */
    @Override
    public List<DmDocVerVO> findAll(DmDocVerQueryDTO dmDocVerQueryDTO, CloudUser cloudUser) {
        List<DmDocVer> dmDocVerList = dmDocVerMapper.findByQuery(dmDocVerQueryDTO, cloudUser);
        return BeanConverter.copyList(dmDocVerList, DmDocVerVO.class);
    }

    /**
     * 新建文档
     *
     * @param dmDocVerInsertDTO
     * @param cloudUser
     */
    @Override
    public void insert(DmDocVerInsertDTO dmDocVerInsertDTO, CloudUser cloudUser) throws Exception {
        //获取文档对象
        DmDocMaster dmDocMaster = BeanConverter.copyProperties(dmDocVerInsertDTO.getDmDocMaster(), DmDocMaster.class);
        dmDocMasterMapper.insert(dmDocMaster, cloudUser);

        //获取文档版本对象
        DmDocVer dmDocVer = BeanConverter.copyProperties(dmDocVerInsertDTO, DmDocVer.class);
        dmDocVer.setDvDocId(dmDocMaster.getDmDocId());

        //设置文档版本内部版本号(默认0版本)
        dmDocVer.setDvInNerver(DocFinal.INTERNAL_VERSION);

        //签入签出状态
        dmDocVer.setDvCheckStatus(false);

        //设置保密级别
        dmDocVer.setDvDocLevel(DocFinal.GENERAL);

        //判断文档是否上传文件
        if (dmDocVer.getDvFileId() == null) {
            //获取文档类型对象
            DmDocc dmDocc = dmDoccMapper.findById(dmDocMaster.getDmDoccId());

            if (dmDocc.getDcTemplateId()!=null){
                //获取文档类型的电子文件对象
                DmFile dmFile = dmFileMapper.findById(dmDocc.getDcTemplateId());

                //根据文件路径获取文件字节数组
                byte[] bytes = fastDFSClient.copyFile(dmFile.getFiStorPath());

                //字节数组转File
                File file = FileUtils.ByteToFile(bytes, dmFile.getFiFileName());

                //文件输入流
                FileInputStream input = new FileInputStream(file);

                //文件输入流转MultipartFile
                MultipartFile multipartFile = new MockMultipartFile(
                        "file", file.getName(), "text/plain", IOUtils.toByteArray(input));

                //文件上传
                Long newFileId = dmFileService.upload(multipartFile, cloudUser);

                //关闭流
                input.close();
                try {
                    if (file.delete()){
                        log.info(file.getName()+"删除完毕");
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
                //设置新的文件id
                dmDocVer.setDvFileId(newFileId);

                //获取文件后缀
                String extName = FilenameUtils.getExtension(dmFile.getFiFileName());

                //判断该文件是否需要发送转换消息队列,并且不是压缩文件
                if (!dmFile.getFiIsCompresSed() && !fileConfig.getPreviewType().contains(extName)) {

                    /*包装task：file，转换类型，原文件id*/
                    //创建转换文件队列实体
                    ConversionTaskQueue conversionTaskQueue = new ConversionTaskQueue();

                    //根据新的文件id
                    DmFile newDmFile = dmFileMapper.findById(newFileId);

                    //设置文件对象进入消息队列
                    conversionTaskQueue.setDmFile(newDmFile);

                    //设置要转换的类型
                    String previewFileType = getPreviewFileTypeUtils.getPreviewFileType(extName, fileConfig.getConversionMap());

                    //判断是否存在该文件要转换的类型
                    if (previewFileType != null) {

                        //设置转换后的文件类型
                        conversionTaskQueue.setType(previewFileType);

                        //发送message到RabbitMQ
                        rabbitTemplate.convertAndSend(DirectConfig.QUEUE, conversionTaskQueue);
                    }
                }
            }
        }
        //新建文档版
        dmDocVerMapper.insert(dmDocVer, cloudUser);
    }

    /**
     * 文档编辑(修改)
     *
     * @param dmDocVerUpdateDTO
     * @param cloudUser
     */
    @Override
    public void update(DmDocVerUpdateDTO dmDocVerUpdateDTO, CloudUser cloudUser) throws Exception {
        //获取文档对象
        DmDocMaster dmDocMaster = dmDocMasterMapper.findById(dmDocVerUpdateDTO.getDmDocMaster().getDmDocId(), cloudUser);

        //文档dto合并文档po
        BeanConverter.copyProperties(dmDocVerUpdateDTO.getDmDocMaster(), dmDocMaster);

        //更新文档
        dmDocMasterMapper.update(dmDocMaster, cloudUser);

        //获取文档版本对象
        DmDocVer dmDocVer = dmDocVerMapper.findById(dmDocVerUpdateDTO.getDvDvId());

        dmDocVer.setDvDocLevel(dmDocVerUpdateDTO.getDvDocLevel());
        //文档版本dto合并文档po
        BeanConverter.copyProperties(dmDocVerUpdateDTO, dmDocVer);
        //更新文档
        dmDocVerMapper.update(dmDocVer, cloudUser);
    }


    /**
     * 文档删除
     *
     * @param dvDvId
     * @param cloudUser
     */
    @Override
    public void deleteByDvDvId(Long dvDvId, CloudUser cloudUser) throws Exception {
        //根据id查询文档版本对象
        DmDocVer dmDocVer = dmDocVerMapper.findById(dvDvId);
        //根据文档版本获取文档id
        Long dmDocId = dmDocVer.getDmDocMaster().getDmDocId();

        //根据文档id获取文档对象
        DmDocMaster dmDocMaster = dmDocMasterMapper.findById(dmDocId, cloudUser);
        //修改文档对象的删除标记
        dmDocMaster.setDmDelFlag(true);
        //保存修改后的文档对象
        dmDocMasterMapper.update(dmDocMaster, cloudUser);

        //修改版本删除标记
        dmDocVer.setDvDelFlag(true);
        //保存修改后的文档版本对象
        dmDocVerMapper.update(dmDocVer, cloudUser);

        //获取文件
        DmFile dmFile = dmDocVer.getDmFile();
        if (dmFile!=null){
            //调用文件删除方法删除服务器中的文件及修改删除标记
            dmFileService.deleteFile(dmFile.getFiFileId(), cloudUser);
        }


    }

    /**
     * 转交所有权
     *
     * @param dvDvId
     * @param dvOwner
     * @param cloudUser
     */
    @Override
    public void updateOwnership(Long dvDvId, Integer dvOwner, CloudUser cloudUser) {
        DmDocVer dmDocVer = dmDocVerMapper.findById(dvDvId);
        //转交人id
        dmDocVer.setDvOwner(dvOwner);
        dmDocVerMapper.update(dmDocVer, cloudUser);
    }

    /**
     * 批量删除
     *
     * @param dvDvIdList
     * @param cloudUser
     */
    @Override
    public void delete(List<Long> dvDvIdList, CloudUser cloudUser) throws Exception {
        //遍历id数组
        for (Long dvDvId : dvDvIdList) {
            //调用单个删除
            this.deleteByDvDvId(dvDvId, cloudUser);
        }
    }

    /**
     * 另存为
     *
     * @param dvDvId
     * @param dmDocName
     * @param dmDocCode
     * @param cloudUser
     */
    @Override
    public void insertSaveAs(Long dvDvId, String dmDocName, String dmDocCode, CloudUser cloudUser) throws Exception {
        //获取文档版本对象
        DmDocVer dmDocVer = dmDocVerMapper.findById(dvDvId);
        //存入文档名称
        dmDocVer.getDmDocMaster().setDmDocName(dmDocName);
        //存入文档编号
        dmDocVer.getDmDocMaster().setDmDocCode(dmDocCode);
        //签入签出状态
        dmDocVer.setDvCheckStatus(false);
        //清空文档主键
        dmDocVer.getDmDocMaster().setDmDocId(null);
        dmDocMasterMapper.insert(dmDocVer.getDmDocMaster(), cloudUser);
        //文档id存入文档版本对象
        dmDocVer.setDvDocId(dmDocVer.getDmDocMaster().getDmDocId());
        //清空文档版本主键
        dmDocVer.setDvDvId(null);
        //设置文档版本所有人
        dmDocVer.setDvOwner(cloudUser.getId());
        //设置文档状态 默认编辑中
        dmDocVer.setDvCtrStatus(DocFinal.EDIT);
        //设置文档级别 默认一般
        dmDocVer.setDvDocLevel(DocFinal.GENERAL);

        dmDocVer.setDvApprovedDate(null);
        dmDocVer.setDvCancelDate(null);

        //判断是否包含文件
        if (dmDocVer.getDvFileId()!=null){
            //文件复制得到文件id
            Long copyFileId = dmFileService.copyFile(dmDocVer.getDvFileId(), cloudUser);

            //把文件id存入文档版本对象
            dmDocVer.setDvFileId(copyFileId);

            //把copy的文件加入队列
            DmFile dmFile = dmFileMapper.findById(copyFileId);

            //获取文件后缀
            String extName = FilenameUtils.getExtension(dmFile.getFiFileName());

            //判断该文件是否需要发送转换消息队列,并且不是压缩文件
            if (!dmFile.getFiIsCompresSed() && !fileConfig.getPreviewType().contains(extName)) {

                /*包装task：file，转换类型，原文件id*/
                //创建转换文件队列实体
                ConversionTaskQueue conversionTaskQueue = new ConversionTaskQueue();

                //设置文件信息对象进入消息队列
                conversionTaskQueue.setDmFile(dmFile);

                //设置要转换的类型
                String previewFileType = getPreviewFileTypeUtils.getPreviewFileType(extName, fileConfig.getConversionMap());

                //判断是否存在该文件要转换的类型
                if (previewFileType != null) {

                    //设置转换后的文件类型
                    conversionTaskQueue.setType(previewFileType);

                    //发送message到RabbitMQ
                    rabbitTemplate.convertAndSend(DirectConfig.QUEUE, conversionTaskQueue);
                }

            }
            dmDocVerMapper.insert(dmDocVer, cloudUser);
        }
    }

    /**
     * 文档详情
     *
     * @param dvDvId
     * @return
     */
    @Override
    public DmDocVerVO findById(Long dvDvId,CloudUser cloudUser) {
        DmDocVer dmDocVer = dmDocVerMapper.findById(dvDvId);
        DmDocVerVO dmDocVerVO = BeanConverter.copyProperties(dmDocVer, DmDocVerVO.class);
        dmDocVerVO.setPermissionByUserIdAndPtId(this.findPermissionByUserIdAndPtId(cloudUser, dmDocVerVO.getDvDvId()));
        return dmDocVerVO;

    }

    /**
     * 版本升级
     *
     * @param dvDvId
     * @param cloudUser
     * @throws Exception
     */
    @Override
    public void newVersion(Long dvDvId, CloudUser cloudUser) throws Exception {
        //根据id查询当前版本
        DmDocVer dmDocVer = dmDocVerMapper.findById(dvDvId);
        //判断当前版本状态是否可以升版
        if ( DocFinal.PUBLISHED.equals(dmDocVer.getDvCtrStatus()) ) {
            //校验是否是最新版本
            if (dmDocVer.getDvNewVersion()) {
                //修改版本标记
                dmDocVer.setDvNewVersion(false);
                dmDocVerMapper.update(dmDocVer, cloudUser);
                DmDocVer newDmDocVer = BeanConverter.copyProperties(dmDocVer, DmDocVer.class);
                //修改新版本数据状态为编辑中
                newDmDocVer.setDvCtrStatus(DocFinal.EDIT);
                //自增内部版本号
                newDmDocVer.setDvInNerver(newDmDocVer.getDvInNerver() + 1);
                //修改外部版本号
                //正则规则：字符串是否是0-9的正整数
                String regex="^[1-9]\\d*|0$";
                Pattern r = Pattern.compile(regex);
                Matcher m = r.matcher(dmDocVer.getDvVerLabel());
                if (m.find()){
                    //数字
                    newDmDocVer.setDvVerLabel(String.valueOf((Integer.parseInt(dmDocVer.getDvVerLabel()))+1));
                }else {
                    //字符: ASCII码+1
                    Integer parseInt = (Integer.parseInt(AscllCodeUtils.stringToAscii(dmDocVer.getDvVerLabel())))+1;
                    newDmDocVer.setDvVerLabel(AscllCodeUtils.asciiToString(String.valueOf(parseInt)));
                }
                //复制电子文件
                //获取新文件信息id、
                if (newDmDocVer.getDvFileId()!=null){
                    Long fileId = dmFileService.copyFile(newDmDocVer.getDvFileId(), cloudUser);
                    //把copy的文件加入队列
                    DmFile dmFile = dmFileMapper.findById(fileId);
                    //获取文件后缀
                    String extName = FilenameUtils.getExtension(dmFile.getFiFileName());
                    //判断该文件是否需要发送转换消息队列,并且不是压缩文件
                    if (!dmFile.getFiIsCompresSed() && !fileConfig.getPreviewType().contains(extName)) {
                        /*包装task：file，转换类型，原文件id*/
                        //创建转换文件队列实体
                        ConversionTaskQueue conversionTaskQueue = new ConversionTaskQueue();
                        //设置文件信息对象进入消息队列
                        conversionTaskQueue.setDmFile(dmFile);
                        //设置要转换的类型
                        String previewFileType = getPreviewFileTypeUtils.getPreviewFileType(extName, fileConfig.getConversionMap());
                        //判断是否存在该文件要转换的类型
                        if (previewFileType != null) {
                            //设置转换后的文件类型
                            conversionTaskQueue.setType(previewFileType);
                            //发送message到RabbitMQ
                            rabbitTemplate.convertAndSend(DirectConfig.QUEUE, conversionTaskQueue);
                        }
                }
                    //设置到新版本中
                    newDmDocVer.setDvFileId(fileId);
                    //清空主键
                    newDmDocVer.setDvDvId(null);
                    newDmDocVer.setDvApprovedDate(null);
                    newDmDocVer.setDvCancelDate(null);
                    //插入新版本到数据库
                    dmDocVerMapper.insert(newDmDocVer, cloudUser);
            } else {
                log.error("该文档不是最新版本,无法升版");
                throw new RuntimeException("该文档不是最新版本,无法升版");
            }
        } else {
            log.error("该版本不是发布状态,无法升版");
            throw new RuntimeException("该版本不是发布状态,无法升版");
        }
    } }

    /**
     * 文档权限
     *
     * @param cloudUser
     * @param dvDvId
     * @return
     */
    @Override
    public String findPermissionByUserIdAndPtId(CloudUser cloudUser, Long dvDvId) {
        //数据对象
        DocPermissionObject docPermissionObject = new DocPermissionObject();
        DmDocVer dmDocVer = dmDocVerMapper.findById(dvDvId);
        docPermissionObject.doc = dmDocVer;
        docPermissionObject.userId= cloudUser.getId();
        if (dmDocVer.getDvIsFlow()){
            docPermissionObject.dmDocVerService=new DmDocVerServiceImpl();
            //获取当文当所处节点的信息
            ProccessTaskVO nowTaskNode = remoteActService.getNowTaskNode(String.valueOf(dvDvId)+ ActConstants.DOC_SUFFIX);
            if (nowTaskNode!=null){
                log.info("处于流程中的文档为："+dmDocVer.getDvDvId());
                //获取流程当前节点名称
                docPermissionObject.currentStep=nowTaskNode.getTaskName();
                log.info("当前节点名称："+nowTaskNode.getTaskName());
                //集合转字符串
                docPermissionObject.nodeUserIdList=StringUtils.join(nowTaskNode.getUserIdList(), ",");
                log.info("当前节点办理人(可多个)："+docPermissionObject.nodeUserIdList);
                //得到文档类型权限定义列表
                List<ObjectPermissionsAuthorization> objectPermissionsList =
                        objectPermissionsAuthorizationMapper.findByObjectTypeId(DocFinal.DOCUMENT_FLOW_RULE,cloudUser);
                String permission = FindPermissionCommon.findPermissionByUserIdAndPtId(cloudUser, docPermissionObject, objectPermissionsList);
                log.info(docPermissionObject.doc.getDmDocMaster().getDmDocName()+"文档权限为："+permission);
                return permission;
            }
        }else{

            //得到文档类型权限定义列表
            List<ObjectPermissionsAuthorization> objectPermissionsList =
                    objectPermissionsAuthorizationMapper.findByObjectTypeId(DocFinal.DOCUMENT_RULE,cloudUser);
            String permission = FindPermissionCommon.findPermissionByUserIdAndPtId(cloudUser, docPermissionObject, objectPermissionsList);
            log.info(docPermissionObject.doc.getDmDocMaster().getDmDocName()+"文档权限为："+permission);
            return permission;
        }
        return null;
    }

    /**
     *文档修改流程权限是否满足
     * @param currentStep  当前节点步骤名称
     * @param userId       当前用户id
     * @param nodeUserIdList   当前节点办理人字符串
     * @param currentStepString  指定的节点名称
     * @return
     */
    @Override
    public Boolean isMeet(String currentStep, Integer userId, String nodeUserIdList, String currentStepString) {
        log.info("当前节点名称："+currentStep);
        log.info("指定节点名称："+currentStepString);
        //指定流程步骤集合(编辑;修改)
        List<String> currentStepList = Arrays.asList(currentStepString.split(";"));
        //指定用户id集合
        List<String> nodeUserList=Arrays.asList(nodeUserIdList.split(","));
        if (nodeUserList.contains(String.valueOf(userId)) && currentStepList.contains(currentStep)){
            log.info("用户"+userId+"在用户集合["+nodeUserIdList+"]中,满足流程修改权限");
            return true;
        }
        return false;
    }

    /**
     * 文档查看流程权限是否满足
     * @param userId
     * @param nodeUserIdList
     * @return
     */
    @Override
    public Boolean isNodeHandlerUser(Integer userId, String nodeUserIdList) {
        log.info("当前用户Id："+userId);
        log.info("节点办理人id："+nodeUserIdList);
        //指定用户id集合
        List<String> nodeUserList=Arrays.asList(nodeUserIdList.split(","));
        if (nodeUserList.contains(String.valueOf(userId))){
            log.info("用户"+userId+"在用户集合["+nodeUserIdList+"]中,满足流程查看权限");
            return true;
        }
        return false;
    }

    @Override
    public List<String> findPermissDocList(CloudUser cloudUser, Long[] dvDvIdArr) {
        List<String> permissionList=new ArrayList<>();
        for (Long aLong : dvDvIdArr) {
            String permissionByUserIdAndPtId = this.findPermissionByUserIdAndPtId(cloudUser, aLong);
            permissionList.add(permissionByUserIdAndPtId);
        }
        return permissionList;
    }

    /**
     * 批量录入
     *
     * @param dmDocVerPLInsertDTOList
     * @param cloudUser
     * @throws Exception
     */
    @Override
    public void plInsert(List<DmDocVerPLInsertDTO> dmDocVerPLInsertDTOList, CloudUser cloudUser) throws Exception {
        //遍历批量集合
        for (DmDocVerPLInsertDTO dmDocVerPLInsertDTO : dmDocVerPLInsertDTOList) {

            //获取文件对象
            MultipartFile file = dmDocVerPLInsertDTO.getFile();

            //上传文件,获取文件id
            Long dvFileId = dmFileService.uploadFile(file, cloudUser);

            //获取文档传输对象
            DmDocMasterInsertDTO dmDocMasterInsertDTO = dmDocVerPLInsertDTO.getDmDocMaster();

            //校验文档代号是否重复
            DmDocMaster findDmDocMaster = dmDocMasterMapper.findByDmDocCode(dmDocMasterInsertDTO.getDmDocCode(), cloudUser);

            if (findDmDocMaster != null) {
                throw new RuntimeException("文档代号: " + dmDocMasterInsertDTO.getDmDocCode() + "重复,批量录入文档失败");
            }

            DmDocMaster dmDocMaster = BeanConverter.copyProperties(dmDocMasterInsertDTO, DmDocMaster.class);

            //存储文档对象
            dmDocMasterMapper.insert(dmDocMaster, cloudUser);

            DmDocVer dmDocVer = BeanConverter.copyProperties(dmDocVerPLInsertDTO, DmDocVer.class);

            //设置文档缺省值
            //设置文档id
            dmDocVer.setDvDocId(dmDocMaster.getDmDocId());

            //设置备注
            dmDocVer.setDvRemark(dmDocVerPLInsertDTO.getDvRemark());

            //设置扩展属性值
            dmDocVer.setDvPropSets(dmDocVerPLInsertDTO.getOtherAttribute());

            //设置文件id
            dmDocVer.setDvFileId(dvFileId);

            //设置数据有效性状态
            dmDocVer.setDvCtrStatus(DocFinal.EDIT);

            //设置文档版本内部版本号
            dmDocVer.setDvInNerver(DocFinal.INTERNAL_VERSION);

            //设置保密级别  默认一般
            dmDocVer.setDvDocLevel(DocFinal.GENERAL);

            //签入签出状态  默认签入
            dmDocVer.setDvCheckStatus(false);

            //保存文档到数据库
            dmDocVerMapper.insert(dmDocVer, cloudUser);
        }
    }
}
